.TH std::partial_order 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::partial_order \- std::partial_order

.SH Synopsis
   Defined in header <compare>
   inline namespace /* unspecified */ {

       inline constexpr /* unspecified */ partial_order = /* unspecified  \fI(since C++20)\fP
   */;

   }
   Call signature
   template< class T, class U >

       requires /* see below */
   constexpr std::partial_ordering

       partial_order( T&& t, U&& u ) noexcept(/* see below */);

   Compares two values using 3-way comparison and produces a result of type
   std::partial_ordering.

   Let t and u be expressions and T and U denote decltype((t)) and decltype((u))
   respectively, std::partial_order(t, u) is expression-equivalent to:

     * If std::is_same_v<std::decay_t<T>, std::decay_t<U>> is true:
          * std::partial_ordering(partial_order(t, u)), if it is a well-formed
            expression with overload resolution performed in a context that does not
            include a declaration of std::partial_order,
          * otherwise, std::partial_ordering(std::compare_three_way()(t, u)), if it is
            well-formed,
          * otherwise, std::partial_ordering(std::weak_order(t, u)), if it is
            well-formed.
     * In all other cases, the expression is ill-formed, which can result in
       substitution failure when it appears in the immediate context of a template
       instantiation.

  Customization point objects

   The name std::partial_order denotes a customization point object, which is a const
   function object of a literal semiregular class type. For exposition purposes, the
   cv-unqualified version of its type is denoted as __partial_order_fn.

   All instances of __partial_order_fn are equal. The effects of invoking different
   instances of type __partial_order_fn on the same arguments are equivalent,
   regardless of whether the expression denoting the instance is an lvalue or rvalue,
   and is const-qualified or not (however, a volatile-qualified instance is not
   required to be invocable). Thus, std::partial_order can be copied freely and its
   copies can be used interchangeably.

   Given a set of types Args..., if std::declval<Args>()... meet the requirements for
   arguments to std::partial_order above, __partial_order_fn models

     * std::invocable<__partial_order_fn, Args...>,
     * std::invocable<const __partial_order_fn, Args...>,
     * std::invocable<__partial_order_fn&, Args...>, and
     * std::invocable<const __partial_order_fn&, Args...>.

   Otherwise, no function call operator of __partial_order_fn participates in overload
   resolution.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

                                  the result type of 3-way comparison that supports all
   partial_ordering               6 operators, is not substitutable, and allows
   (C++20)                        incomparable values
                                  \fI(class)\fP
   strong_order                   performs 3-way comparison and produces a result of
   (C++20)                        type std::strong_ordering
                                  (customization point object)
   weak_order                     performs 3-way comparison and produces a result of
   (C++20)                        type std::weak_ordering
                                  (customization point object)
                                  performs 3-way comparison and produces a result of
   compare_partial_order_fallback type std::partial_ordering, even if operator<=> is
   (C++20)                        unavailable
                                  (customization point object)

.SH Category:
     * Todo no example
